home *** CD-ROM | disk | FTP | other *** search
/ isnet Internet / Isnet Internet CD.iso / prog / hiz / 09 / 09.exe / adynware.exe / perl / lib / adynware / prune.pm < prev    next >
Encoding:
Text File  |  1999-12-28  |  8.8 KB  |  287 lines
  1. require 5.004;
  2. use strict;
  3. #use diagnostics;
  4. package prune;
  5. use IO::File;
  6. use adynware::utility_file;
  7. use adynware::utility;
  8.  
  9. my $prune__blockSize = 0;
  10. my $prune__cacheDirectory = 0;
  11. my %prune__data = ();
  12. my $prune__targetSize = 0;
  13.  
  14.  
  15. sub RoundFileLength
  16. {
  17.         my($length) = @_;
  18.         my $rounded = utility_file::RoundFileLength($prune__blockSize, $length);
  19.         #print "rounding($length) = $rounded\n";
  20.         return $rounded;
  21. }
  22.  
  23. sub Get
  24. {
  25.         my($name, $index) = @_;
  26.         my $value = $prune__data{$name};
  27.         return $$value[$index];
  28. }
  29.  
  30.  
  31. sub Length
  32. {
  33.         my($name) = @_;
  34.         return Get($name, 0);
  35. }
  36.  
  37. sub Time
  38. {
  39.         my($name) = @_;
  40.         return Get($name, 1);
  41. }
  42.  
  43. sub X
  44. {
  45.         my($name) = @_;
  46.         return Get($name, 2);
  47. }
  48. sub Dump
  49. {
  50.         my($key) = @_;
  51.         my $data = $prune__data{$key};
  52.         my($length, $time, $x) = @$data;
  53.         return "$key:l=$length" . "t=$time" . "x=$x\n";
  54. }
  55.  
  56. sub ReadCacheDatabase
  57. {
  58.         my $file = new IO::File("< $prune__cacheDirectory/cache.db") or return;
  59.         for (my $j = 0; <$file>; $j++)
  60.         {
  61.                 if (/(.*):l=(\d+)t=(\d+)x=(\d+)$/i)
  62.                 {
  63.                         my($fileName, $length, $time, $x) = ($1, $2, $3, ($4 - 1));
  64.                         print "examining:$fileName: $length\n";
  65.                         if ($x < 0
  66.                         or $fileName =~ /\.(exe|zip)$/i
  67.                         or $length > utility::GetMaxCacheFileSize())
  68.                         {
  69.                                 unlink(utility::GetCacheName($fileName));
  70.                         }
  71.                         else
  72.                         {
  73.                                 $prune__data{$fileName} = [$length, $time, $x];
  74.                         }
  75.                 }
  76.                 else
  77.                 {
  78.                         print "cache database line $j ($_) corrupted; correcting...\n";
  79.                 }
  80.         }
  81.         $file->close();
  82. }
  83.  
  84. sub WriteCacheDatabase
  85. {
  86.         my $file = new IO::File("> $prune__cacheDirectory/cache.db") or (utility::Log("could not open $prune__cacheDirectory/cache.db: $!"), return);
  87.         foreach my $key (keys %prune__data)
  88.         {
  89.                 print $file Dump($key);
  90.         }
  91.         $file->close();
  92. }
  93.  
  94. sub GetCurrentSize
  95. {
  96.         my @keys = keys %prune__data;
  97.                         
  98.         my $size = RoundFileLength(67 * scalar(@keys));
  99.                         
  100.         foreach my $key (@keys)
  101.         {
  102.                 $size += RoundFileLength(Length($key));
  103.                 #print "GetCurrentSize\t$key\t", Length($key), "\t$size\n";
  104.         }
  105.         return $size;
  106. }
  107.  
  108. sub SortItems
  109. {
  110.         if (Dump($a) !~ /t=(\d+)x=(-?\d+)$/)
  111.         {
  112.                 utility::Log("Sort Items:" . Dump($a));
  113.                 return -1;
  114.         }
  115.         my($time1, $x1) = ($1, $2);
  116.         
  117.         if (Dump($b) !~ /t=(\d+)x=(-?\d+)$/)
  118.         {
  119.                 utility::Log("Sort Items:" . Dump($a));
  120.                 return  1;
  121.         }
  122.         my($time2, $x2) = ($1, $2);
  123.                                                                 
  124.         return 1 if ($x1 > $x2);
  125.         return -1 if ($x1 < $x2);
  126.         return 1 if ($time1 > $time2);
  127.         return -1 if ($time1 < $time2);
  128.         return 0;
  129. }
  130.  
  131. sub Prune
  132. {
  133.         my($currentSize, $targetSize, @sortedItems) = @_;
  134.         foreach my $item (@sortedItems)
  135.         {
  136.                 print Dump($item);
  137.                 my $cacheFileName = utility::GetCacheName($item);
  138.                 if (! -f $cacheFileName)
  139.                 {
  140.                         print "$cacheFileName does not exist";
  141.                 }
  142.                 elsif ($targetSize >= $currentSize) 
  143.                 {
  144.                         # file exists, but will be deleted
  145.                         unlink("$cacheFileName") or print "could not unlink $cacheFileName:$!\n";
  146.                 }
  147.                 else
  148.                 {
  149.                         next;    # file exists, and wasn't deleted
  150.                 }
  151.                 my $length = RoundFileLength(Length($item));
  152.                 $currentSize -= $length;
  153.                 delete($prune__data{$item});
  154.                 print "$currentSize---------------$cacheFileName no longer exists ($length)\n";
  155.         }
  156.         print "size is $currentSize";
  157.         return $currentSize;
  158. }
  159.  
  160. sub RemovePageAndItsChildren
  161. {
  162.         my($target) = @_;
  163.         ReadCacheDatabase();
  164.         my $currentSize = GetCurrentSize();
  165.         foreach my $item (keys %prune__data)
  166.         {
  167.                 if ($item =~ $target)
  168.                 {
  169.                         my $cacheFileName = utility::GetCacheName($item);
  170.                         unlink("$cacheFileName") or print "could not unlink $cacheFileName ($item):$!\n";
  171.                         $currentSize -= RoundFileLength(Length($item));
  172.                         print "$currentSize----------------------unlinking $cacheFileName\n";
  173.                 }
  174.         }
  175.         return $currentSize;
  176. }
  177.  
  178. sub GatherPrefetchTargets
  179. {
  180.         my($prefetchMaxItems, $sortedItemsReference, $noCacheListReference) = @_;
  181.         if (!$prefetchMaxItems)
  182.         {
  183.                 print "prune::GatherPrefetchTargets: prefetchMaxItems==0";
  184.                 return ();
  185.         }
  186.                 
  187.         my @sortedItems = @$sortedItemsReference;
  188.         my %noCacheList = %$noCacheListReference;
  189.         my @targets = ();
  190.                                                         
  191.         my $cutoffTime = time() - (24 * 60 * 60);
  192.         for (my $j = $#sortedItems; $j > 0; $j--)
  193.         {
  194.                 my $page = $sortedItems[$j];
  195.                 if (X($page) <= 0)
  196.                 {
  197.                         my $cacheFileName = utility::GetCacheName($page);
  198.                         print "prune::Gather prefetch targets: rm $cacheFileName\n";
  199.                         unlink("$cacheFileName") or print "could not unlink $cacheFileName:$!\n";
  200.                         next;                        
  201.                 }
  202.  
  203.                 my $itemTime = Time($page);
  204.                 defined $itemTime or (utility::Log("Time($page) returned an undefined value"), next);
  205.                 print "item:$sortedItems[$j]: ", (time() - $itemTime), "\n";
  206.                                                 
  207.                 $page =~ m{^(.*?)/};
  208.                 my $machine = $1;
  209.                 
  210.                 if ($cutoffTime > $itemTime 
  211.                 and !defined $noCacheList{$page}
  212.                 and !defined $noCacheList{"$machine/"})
  213.                 {
  214.                         $page =~ m{(.*?)/} or next;
  215.                         my $machine = $1;
  216.                         next if utility::IsImage($page);
  217.                                                                                                 
  218.                         my $cacheFileName = utility::GetCacheName($page);
  219.                         if (! -r $cacheFileName)
  220.                         {
  221.                                 delete($prune__data{$page});
  222.                         }
  223.                         else
  224.                         {
  225.                                 print "    prefetch\n";
  226.                                                         
  227.                                 push(@targets, $page);
  228.                                 last if scalar(@targets) >= $prefetchMaxItems;
  229.                         }
  230.                 }
  231.         }
  232.         return @targets;
  233. }
  234.  
  235. sub PruneBrowserCatalog
  236. {
  237.         my $file = new IO::File("< $prune__cacheDirectory/b_cache.db") or return;
  238.         my %items = ();
  239.         while (<$file>)
  240.         {
  241.                 $items{$_} = 1;
  242.         }
  243.         $file->close();
  244.         $file = new IO::File("> $prune__cacheDirectory/b_cache.db") or (utility::Log("cannot overwrite $prune__cacheDirectory/b_cache.db:$!"), return);
  245.         foreach my $item (keys %items)
  246.         {
  247.                 print $file $item;
  248.         }
  249.         $file->close();
  250. }
  251.  
  252.  
  253. sub Init
  254. {
  255.         my($blockSize, $cacheDirectory, $limitSize, $prefetchMaxItems, $noCacheListReference) = @_;
  256.         $prune__blockSize      = $blockSize;
  257.         $prune__cacheDirectory = $cacheDirectory;
  258.                         
  259.         if (! -d $prune__cacheDirectory)
  260.         {
  261.                 print "prune::Init creating $prune__cacheDirectory\n";
  262.                 if (!mkdir($prune__cacheDirectory, '777'))
  263.                 {
  264.                         utility::Die("prune could not create $prune__cacheDirectory:$!");
  265.                 }
  266.         }
  267.  
  268.         
  269.         PruneBrowserCatalog();
  270.         
  271.         ReadCacheDatabase();
  272.                 
  273.         my $currentSize = GetCurrentSize();
  274.         my @sortedItems = sort SortItems keys %prune__data;
  275.         if ($limitSize < $currentSize)
  276.         {
  277.                 $currentSize = Prune($currentSize, $limitSize, @sortedItems);                
  278.                 @sortedItems = sort SortItems keys %prune__data;
  279.         }
  280.         my @prefetchTargets = GatherPrefetchTargets($prefetchMaxItems, \@sortedItems, $noCacheListReference);
  281.         WriteCacheDatabase();
  282.                        
  283.         return [$currentSize, @prefetchTargets];
  284. }
  285. 1;
  286.  
  287.